package scene;
//package scene;
//
//
//import java.awt.Point;
//
//import java.nio.IntBuffer;
//
//
//import javax.media.opengl.GL;
//import javax.media.opengl.GLAutoDrawable;
//import javax.media.opengl.GLCanvas;
//import javax.media.opengl.GLCapabilities;
//import javax.media.opengl.GLEventListener;
//import javax.media.opengl.glu.GLU;
//
//
//
//
//
//import application.Rdm;
//
//
//
//import com.sun.opengl.util.BufferUtil;
//import com.sun.opengl.util.FPSAnimator;
//import com.sun.opengl.util.GLUT;
//
//
//
//
//
//public class CopyOfGLScene3Dsauvegarde extends GLCanvas implements GLEventListener {
//
//
//
//
//	/**
//     *
//     */
//    private static final long serialVersionUID = 1L;
//
//    double scale = 0;
////    float rotation[]={0,0,0};
//
//
//
//
//
//	protected GLCapabilities caps;
//
//    protected CountFPS countfps;
//
//    public int wheelRotation;
//
//    //protected JFrame frame;
//
//    private Couleur tabCouleurs[];
//
//    private static CameraSpherique camera;
//
//
//
//
//

//
//    /**
//     * num�ro de l'objet s�lectionn�
//     * selection<-0 pour aucun objet s�lectionn�
//     */
//    private int selection = 0;
//    public Point mouseCoordXY = new Point();
//
//
//
//
//
//    double zNear = -60.0;
//    double zFar = 60.0;
//
//    double xNear = -1;
//    double xFar = 1;
//
//    double yNear = -1;
//    double yFar = 1;
//
//    boolean droite=false,haut=false,bas=false,gauche=false;
//    boolean pick=false;
//
//    final GLU glu = new GLU();
//    final GLUT glut = new GLUT();
//
//
//    float color[] = new float[4];
//
//    private final static int BUFSIZE = 512;
//
//
//    private Scene3DUtilisateurInterface scene3DUtilisateur;
//
//    //private ControleurWiiCameraSpherique wiimote;
//
//
//
//
//    public CopyOfGLScene3Dsauvegarde(Scene3DUtilisateurInterface _scene3d)
//    {
//    	this();
//
//    	/**
//    	 * on pr�cise la classe Scene3DUtilisateur
//    	 */
//    	this.setScene3DUtilisateur(_scene3d);
//    }
//
//    public CopyOfGLScene3Dsauvegarde()
//    {
//
//        this(new GLCapabilities());
//
//
//
//        /**
//         * initialisation d'un compteur pour
//         * connaitre le nombre de fps
//         */
//        countfps = new CountFPS();
//
//
//		/**
//		 * Cr�ation de l'Animator
//		 * comme expliqu� dans l'article
//		 */
//		FPSAnimator animator = new FPSAnimator(this,60);
//	animator.setRunAsFastAsPossible(true);
//
//
//		/**
//		 * Nous d�marrons l'Animator qui
//		 * va se charger de faire des appels
//		 * � la m�thode display();
//		 */
//		animator.start();
//
//
//
//
//
//		/**
//		 * enregistrer les �couteurs
//		 */
//        this.addGLEventListener(this);
//        GLScene3DKeyHandler keyHandler = new GLScene3DKeyHandler(this);
//        this.addKeyListener(keyHandler);
//        GLScene3DMouseHandler mouseHandler = new GLScene3DMouseHandler(this);
//        this.addMouseListener(mouseHandler);
//        this.addMouseMotionListener(mouseHandler);
//        this.addMouseWheelListener(mouseHandler);
//
//
//    }
//
//
//
//    public CopyOfGLScene3Dsauvegarde(GLCapabilities _caps)
//    {
//
//
//
//    	super(_caps);
//
//    	caps = _caps;
//        /**
//         * activer le double buffer
//         */
//    	caps.setStereo(true);
//        caps.setDoubleBuffered(true);
//        System.out.println(caps.getStereo());
//        caps.setHardwareAccelerated(true);
//
//
//
//
//    }
//
//
//    public double getScale() {
//        return scale;
//    }
//
//
//    public void setScale(double _scale) {
//        scale = _scale;
//    }
//
//
//    /**
//     * reshape() sera appel�e si la fen�tre d'affichage est redimensionn�e
//     */
//    public void reshape(GLAutoDrawable glDrawable, int x, int y, int width, int height)
//
//    {
//
//        final GL gl = glDrawable.getGL();
//
//
//
//
//
//        System.out.println("Width : "+width+" Height: "+height);
//
//        if(height <= 0)
//
//            height = 1;
//
//
//        /*
//
//         * Set the current Viewport region
//
//         * The Viewport is the region of the window in which the scene is drawn
//
//         *
//
//         * Here: all the space
//
//         */
//        if(width<height)
//            gl.glViewport((height-width)/2, 0, width, width);
//        else
//            gl.glViewport((width-height)/2, 0, height, height);
////        gl.glViewport(0,0, width, height);
//
//
//
//        positionnerCamera(gl);
//
//		/**
//		 * focus sur le canvas
//		 */
//		this.requestFocusInWindow();
//
//    }
//
//    public void init(GLAutoDrawable drawable) {
//
//
//
//
//
//
//
//
//        /**
//         * GLEventListener renvoie un contexte (drawable)
//         * que nous allons utiliser pour instancier un objet
//         * de type GL, qui nous permettra d'utiliser
//         * les fonctions OpenGL, bien que dans cet article
//         * cela reste encore inutile
//         */
//        final GL gl = this.getGL();
//
//
//
//        /**
//         * Cette fonction permet de d�sactiver
//         * la syncronisation verticale, ind�pendemment
//         * de la plateforme utilis�e
//         */
//        gl.setSwapInterval(1);
//
//
//        gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_POLYGON);
//
//        /**
//         * type d'ombrage : facettes ou lisse
//         */
//
//        /**
//         * activer le test de profondeur
//         */
//        gl.glDepthFunc(GL.GL_LEQUAL);                // Le type de test de profondeur a effectuer LESS ou LEQUAL??
//        gl.glEnable(GL.GL_DEPTH_TEST);
//        gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);  // Le calcul des perspectives jolies
//        gl.glClearDepth(1.0);
//        gl.glDepthRange(0.0, 1.0); /* default z-mapping */
//
//        gl.glShadeModel(gl.GL_SMOOTH);
//
//        /**
//         * culling
//         */
////        gl.glEnable(gl.GL_CULL_FACE); // Activation du culling
////        gl.glCullFace(gl.GL_BACK); // Culling des faces dont la normale est orient�e � l'encontre du sens de la cam�ra
//
//
//        /* select clearing color (background) color */
//        this.getScene3DUtilisateur().definirCouleurDeFond(gl);
//        //gl.glClearColor(0f, 0f, 0f, 1f);
//        gl.glLineWidth(1.0f);
//        gl.glPointSize(2.f);
//
//
//
//
//        /**
//         * d�finition de la cam�ra 1
//         */
//        //this.setCamera(new CameraSpherique(1f,1f,1f,0,0,0,0,1,0));
//
//        this.setCamera(new CameraSpherique(0.75578276f,0.58778477f,0.2899259f,0,0,0,0,1,0));
//        this.getScene3DUtilisateur().positionnerCamera();
//
//
//
//
//
//
//        /**
//         * d�finition des lumi�res et initialisation
//         */
//        float[] lightDiffuse = {1.0f, 1.0f, 1.0f, 1.0f};    // diffuse : color where light hit directly the object's surface
//        float[] lightAmbient = {1f, 1f, 1f, 1.0f};    //red ambient : color applied everywhere
//        float[] lightSpecular = {1f, 1f, 1f, 1.0f};
//        float[] lightPosition0 = {this.getCamera().getEyeX(),
//                this.getCamera().getEyeY(),
//                this.getCamera().getEyeZ(),
//                0.0f};
//
//        //Ambient light component
//        gl.glLightfv(GL.GL_LIGHT0, GL.GL_AMBIENT, lightAmbient,0);
//        //Diffuse light component
//        gl.glLightfv(GL.GL_LIGHT0, GL.GL_DIFFUSE, lightDiffuse,0);
//
//        gl.glLightfv(GL.GL_LIGHT0, GL.GL_SPECULAR, lightSpecular,0);
//
//        //Light position
//        gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, lightPosition0,0);
//
//        //Enable the first light and the lighting mode
//        gl.glEnable(GL.GL_LIGHT0);
//        gl.glEnable(GL.GL_LIGHTING);
//
//
//
//
//        /**
//         * initialiser les DisplayLists
//         */
//        this.getScene3DUtilisateur().initialiserMesDisplayLists(gl);
//
//
//        /**
//         * activer transparence
//         */
//        gl.glBlendFunc(GL.GL_SRC_ALPHA,gl.GL_ONE_MINUS_SRC_ALPHA) ;
//        gl.glEnable(GL.GL_BLEND);
//
//
//        /**
//         * initialisation de la configuration de la sc�ne
//         * et premi�re disposition de la cam�ra
//         * (normalement reshape est appel�e une premi�re fois
//         * au lancement)
//         */
//        positionnerCamera(gl);
//
//
//
//
//    }
//
//
//
//    public void display(GLAutoDrawable drawable) {
//
//    	this.getCountfps().start();
//
//        GL gl = this.getGL();
//
//
//        gl.glDrawBuffer(GL.GL_BACK_LEFT);
//        /* clear all pixels */
//        gl.glClear(GL.GL_COLOR_BUFFER_BIT);
//        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
//
//
//        /**
//         * d�placements cam�ra
//         */
//        deplacerCamera(gl);
//
//
//        /**
//         * mise � jour de la position de la cam�ra par d�faut
//         */
//        positionnerCamera(gl);
//
//
//        /**
//         * Zoom sur la sc�ne
//         */
//        miseEchelleScene(gl);
//
//
//        /**
//         * afficher le rep�re
//         */
//        Dessin.dessinerRepereSimple(gl);
//
//        /**
//         * on affiche ce que l'on d�sire
//         */
//        afficherDansDisplay(gl,GL.GL_RENDER);
//
//
//
//
//
//        /**
//         * Travail sur le picking d'objets 3D en opengl
//         */
//        //if(pick) this.pickObjets(gl);
//
//
//
//
//
//        /*
//         * don't wait! start processing buffered OpenGL routines
//         */
//
//        gl.glFlush();
//
//        this.getCountfps().stop();
//        //System.out.println(this.getCountfps().nbFPS());
//
//
//
//    }
//
//    /**
//     * displayChanged() est appel�e si le mode d'affichage par exemple
//     * est modifi�. Cependant nous n'impl�menterons pas cette m�thode.
//     */
//    public void displayChanged(GLAutoDrawable drawable, boolean modeChanged,
//            boolean deviceChanged) {
//
//
//    	System.out.println("affichage modifi�??");
//
//    }
//
//
//
//
//
//
//
//
//
//
//
//
////    private void effectuerRotation(GL gl)
////    {
////
////        //System.out.println("valeur:"+getRotation()[0]+getRotation()[1]+getRotation()[2]);
////        if(getRotation()[0] !=0 || getRotation()[1] != 0 || getRotation()[2] != 0)
////            gl.glRotatef(1f,getRotation()[0],getRotation()[1],getRotation()[2]);
////        float [] aucuneRotation = {0,0,0};
////        setRotation(aucuneRotation);
////
////    }
////
////
////    protected float[] getRotation() {
////        return rotation;
////    }
////
////
////    protected void setRotation(float[] rotation) {
////        this.rotation = rotation;
////    }
//
//
//
//
//
//
////    private ControleurWiiCameraSpherique getWiimote() {
////        return wiimote;
////    }
////
////
////    private void setWiimote(ControleurWiiCameraSpherique wiimote) {
////        this.wiimote = wiimote;
////    }
//
//
//    protected static CameraSpherique getCamera() {
//        return camera;
//    }
//
//
//    private void setCamera(CameraSpherique camera) {
//        this.camera = camera;
//    }
//
//
//
//
//
//
//	private Couleur[] getTabCouleurs() {
//		return tabCouleurs;
//	}
//
//
//	private void setTabCouleurs(Couleur[] tabCouleurs) {
//		this.tabCouleurs = tabCouleurs;
//	}
//
//	private void attribuerPaletteDeCouleurs(int _nbMaxCouleurs)
//	{
//        tabCouleurs=new Couleur[_nbMaxCouleurs];
//        for(int i=0; i<tabCouleurs.length; i++)
//        {
//        	/**
//        	 * seuil alpha fix� � 1
//        	 */
//        	tabCouleurs[i] = new Couleur(Rdm.randomFloat(),Rdm.randomFloat(),Rdm.randomFloat(),1);
//
//
//        }
//	}
//
//
//
//	/**
//	 * positionner une cam�ra
//	 * @param gl
//	 */
//	private void positionnerCamera(GL gl)
//	{
//
//
//        /**
//         * recadrage de la cam�ra sur la sc�ne
//         */
//        gl.glMatrixMode(GL.GL_PROJECTION);
//        gl.glLoadIdentity();
//        gl.glOrtho(-Math.abs(this.getCamera().getRayon()),
//        		Math.abs(this.getCamera().getRayon()),
//        		-Math.abs(this.getCamera().getRayon()),
//        		Math.abs(this.getCamera().getRayon()),zNear,zFar);
////        gl.glOrtho(xNear,xFar,yNear,yFar,zNear,zFar);
//        gl.glMatrixMode(GL.GL_MODELVIEW);
//        gl.glLoadIdentity();
//        glu.gluLookAt(this.getCamera().getEyeX(), this.getCamera().getEyeY(),
//                this.getCamera().getEyeZ(), this.getCamera().getLookAtX(),
//                this.getCamera().getLookAtY(), this.getCamera().getLookAtZ(),
//                this.getCamera().getUpX(),
//                this.getCamera().getUpY(),this.getCamera().getUpZ());
//
//        /**
//         * une mise � jour de la position de la lumi�re
//         * attach�e � la cam�ra courante
//         *
//         */
//        this.getCamera().updateLightCamera(gl,GL.GL_LIGHT0);
//
//
//
//
//	}
//
//	/**
//	 * mise � jour de l'�chelle
//	 * @param gl
//	 */
//	private void miseEchelleScene(GL gl)
//	{
//	       if(this.getScale()!=0)
//	        {
//
//
//	            xNear = xNear*getScale();
//	            yNear = yNear*getScale();
//	            yFar = yFar*getScale();
//	            xFar = xFar*getScale();
//	            /**
//	             * ne pas mettre � jour les zNear et zFar via la modification
//	             * du zoom sur la sc�ne
//	             */
//	            //zNear = zNear*getScale();
//	            //zFar = zFar*getScale();
//
//	            //gl.glScaled(getScale(),getScale(),getScale());
//	            this.getCamera().setRayon((float) (this.getCamera().getRayon()*getScale()));
//
//	            setScale(0);
//	        }
//
//	}
//
//
//	/**
//	 * D�place-t-on la cam�ra ??
//	 * @param gl
//	 */
//	private void deplacerCamera(GL gl)
//	{
//    	/**
//    	 * choix des directions
//    	 */
//        if(droite)
//    	{
//
//        	this.getCamera().incTheta(1);
//         }
//        if(haut)
//        {
//
//        	this.getCamera().incRo(1);
//        }
//        if(gauche)
//    	{
//
//        	this.getCamera().incTheta(-1);
//         }
//        if(bas)
//        {
//        	this.getCamera().incRo(-1);
//        }
//
//
//        /**
//         * calcul des nouvelles coordonn�es de la position de la cam�ra
//         */
//        if(droite||gauche||haut||bas)
//        {
//        	this.getCamera().setEyeX((float) (this.getCamera().getNewOrigineX()));
//        	this.getCamera().setEyeY((float) (this.getCamera().getNewOrigineY()));
//        	this.getCamera().setEyeZ((float) (this.getCamera().getNewOrigineZ()));
//        }
//
//
////      /**
////      * on affiche les informations de position de la cam�ra
////      */
////     System.out.println("R:"+this.getCamera1().getRayon()+" - Aph:"+this.getCamera1().getAlpha()+ " - Ro:"+this.getCamera1().getRo()+
////            " - X:"+this.getCamera1().getOrigineX()+" - Y:"+this.getCamera1().getOrigineY()
////             +" - Z:"+this.getCamera1().getOrigineZ());
//	}
//
//
//
//
//
//
//
//	/**
//	 * desiner objets � s�lectionner � la souris
//	 */
//	private void dessinerObjetsASelectionner(GL gl, int mode)
//	{
//
//
//
//	    /**
//	     * jolie sph�re "fil de fer" pour se rep�rer
//	     */
//	    gl.glPushMatrix();
//
//	    if(mode == GL.GL_SELECT)
//	    {
//
//	    	gl.glPushName(1);
//	    	gl.glBegin(GL.GL_POINTS);
//	        gl.glVertex3d(0,0.5,0);
//	    	gl.glEnd();
//	    	gl.glPopName();
//	    }
//	    else
//	    {
//	    	gl.glTranslatef(0f,0.5f,0f);
//	    	gl.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, Couleur.GREY.getGFloat4Value(), 0);
//	    	glut.glutSolidSphere(0.05f,30,30);
//	    }
//	    gl.glPopMatrix();
//
//	    /**
//	     * jolie sph�re "fil de fer" pour se rep�rer
//	     */
//	    gl.glPushMatrix();
//
//	    if(mode == GL.GL_SELECT)
//	    {
//	    	gl.glPushName(2);
//
//	    	gl.glBegin(GL.GL_POINTS);
//	        gl.glVertex3d(0.5,0,0);
//	    	gl.glEnd();
//	    	gl.glPopName();
//
//	    }
//	    else
//	    {
//	    	gl.glTranslatef(0.5f,0f,0f);
//	    	gl.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, Couleur.GREEN.getGFloat4Value(), 0);
//	    	glut.glutSolidSphere(0.05f,30,30);
//	    }
//	    gl.glPopMatrix();
//
//	    /**
//	     * jolie sph�re "fil de fer" pour se rep�rer
//	     */
//	    gl.glPushMatrix();
//
//	    if(mode == GL.GL_SELECT)
//	    {
//	    	gl.glPushName(2);
//
//	    	gl.glBegin(GL.GL_POINTS);
//	        gl.glVertex3d(0,0,0.5);
//	    	gl.glEnd();
//	    	gl.glPopName();
//
//	    }
//	    else
//	    {
//	    	gl.glTranslatef(0f,0f,0.5f);
//	    	gl.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, Couleur.BLUE.getGFloat4Value(), 0);
//	    	glut.glutSolidSphere(0.05f,30,30);
//	    }
//	    gl.glPopMatrix();
//
//
//
//	    /**
//	     * jolie sph�re "fil de fer" pour se rep�rer
//	     */
//	    gl.glPushMatrix();
//
//	    if(mode == GL.GL_SELECT)
//	    {
//	    	gl.glPushName(4);
//
//	    	gl.glBegin(GL.GL_POINTS);
//	        gl.glVertex3d(0.5,0.5,0.5);
//	    	gl.glEnd();
//	    	gl.glPopName();
//
//	    }
//	    else
//	    {
//	    	gl.glTranslatef(0.5f,0.5f,0.5f);
//	    	gl.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, Couleur.RED.getGFloat4Value(), 0);
//	    	glut.glutSolidSphere(0.05f,30,30);
//	    }
//	    gl.glPopMatrix();
//
//
//	}
//
//
//	/**
//	 * on "prend" (s�lectionne les objets)
//	 * @param gl
//	 */
//	private void pickObjets(GL gl)
//	{
//
//
//
//		int[] selectBuf = new int[BUFSIZE];
//		IntBuffer selectBuffer = BufferUtil.newIntBuffer(BUFSIZE);
//		int hits;
//		int viewport[] = new int[4];
//
//		gl.glGetIntegerv(GL.GL_VIEWPORT, viewport, 0);
//		gl.glSelectBuffer(BUFSIZE, selectBuffer);
//		gl.glRenderMode(GL.GL_SELECT);
//
//		/**
//		 * This function creates an empty name stack. You are required to call
//		 *  this function to initialize the stack prior to pushing names
//		 */
//        gl.glInitNames();
//
//
//
//        gl.glMatrixMode(GL.GL_PROJECTION);
//        gl.glPushMatrix();
//        gl.glLoadIdentity();
//		glu.gluPickMatrix((double) mouseCoordXY.x,
//				(double) (viewport[3]-mouseCoordXY.y),
//				20.0, 20.0, viewport, 0);
//        gl.glOrtho(-Math.abs(this.getCamera().getRayon()),
//        		Math.abs(this.getCamera().getRayon()),
//        		-Math.abs(this.getCamera().getRayon()),
//        		Math.abs(this.getCamera().getRayon()),zNear,zFar);
//
//
//        gl.glMatrixMode(GL.GL_MODELVIEW);
//
//        afficherDansDisplay(gl,GL.GL_SELECT);
//        //dessinerNoeuds(gl,GL.GL_SELECT);
//
//        gl.glMatrixMode(GL.GL_PROJECTION);
//        gl.glPopMatrix();
//        gl.glMatrixMode(GL.GL_MODELVIEW);
//        gl.glFlush();
//
//        //gl.glMatrixMode(GL.GL_MODELVIEW);
//        hits = gl.glRenderMode(GL.GL_RENDER);
//        selectBuffer.get(selectBuf);
//        processHits(hits,selectBuf);
//
//
//
//
//
//
//
//
//
//
//	}
//
//	/**
//	 * on identifie les objets s�lectionn�s
//	 * @param hits
//	 * @param buffer
//	 */
//	private void processHits(int hits, int buffer[])
//	{
//		int names, ptr = 0;
//
//		//if(hits>0) System.out.println("hits = "+hits);
//
//		for (int i = 0; i < hits; i++)
//		{
//
//			/**
//			 * les infos concernant la s�lection d'un objet
//			 */
////			System.out.println("Number: "+(int)buffer[i * 4]+
////					" \nMin Z: "+(float)buffer[i * 4 + 1]/2147483647+
////					" \nMax Z: " +(float)buffer[i * 4 + 2]/2147483647+
////					" \nName on stack: "+(int)buffer[i * 4 + 3]);
//
//			/**
//			 * on r�cup�re le num�ro de l'objet s�lectionn�
//			 */
//			int tmp = (int)buffer[i * 4 + 3];
//			/**
//			 * si l'objet est d�j� s�lectionn� on annule la s�lection
//			 */
//			if(tmp==selection)
//			{
//				selection = 0;
//
//			}
//			else{
//					selection=tmp;
//					System.out.println("objet s�lectionn� :"+selection);
//			}
//
//			/**
//			 * un m�me objet a �t� d�selectionn� ou bien un nouvel objet a �t�
//			 * s�lectionn�. On d�sactive la s�lection d'objets.
//			 */
//			pick=false;
//
//		}
//		if (hits == 0)
//		{
//			//System.out.println("Rien du tout sous la souris\n");
//
//		}
//
//
//
//
//
//
//	}
//
//
//
//
//	private void afficherDansDisplay(GL gl, int mode)
//	{
//
//		Dessin.calculNormal(gl);
//		gl.glCallList(Dessin.REPERE);
//		afficherScene3DUtilisateur(gl);
//
//
//
//	}
//
//
//	private CountFPS getCountfps() {
//		return countfps;
//	}
//
//
//	private void setCountfps(CountFPS countfps) {
//		this.countfps = countfps;
//	}
//
//
//
//	public int getSelection() {
//		return selection;
//	}
//
//
//
//	private void setSelection(int selection) {
//		this.selection = selection;
//	}
//
//	private void afficherScene3DUtilisateur(GL gl){
//
//		getScene3DUtilisateur().afficherDansMaScene3D(gl);
//
//
//	}
//
//	protected Scene3DUtilisateurInterface getScene3DUtilisateur() {
//		return scene3DUtilisateur;
//	}
//
//	protected void setScene3DUtilisateur(Scene3DUtilisateurInterface scene3DUtilisateur) {
//		this.scene3DUtilisateur = scene3DUtilisateur;
//	}
//
//
//
//}
